<script>
    function diff(newNode, oldNode) {
        // 如果新节点不存在，则直接删除旧节点
        if (!newNode) {
            return {
                type: 'REMOVE',
                node: oldNode
            };
        }

        // 如果旧节点不存在，则直接添加新节点
        if (!oldNode) {
            return {
                type: 'ADD',
                node: newNode
            };
        }

        // 如果节点类型不同，则直接替换
        if (newNode.type !== oldNode.type) {
            return {
                type: 'REPLACE',
                node: newNode
            };
        }

        // 如果节点类型相同但是节点值不同，则直接更新节点
        if (newNode.value !== oldNode.value) {
            return {
                type: 'UPDATE',
                node: newNode
            };
        }

        // 如果节点类型相同且节点值也相同，则比较子节点
        const patches = [];

        const newChildren = newNode.children || [];
        const oldChildren = oldNode.children || [];

        // 将新旧子节点的 key 提取出来，方便后面比较
        const newKeys = newChildren.map(child => child.key);
        const oldKeys = oldChildren.map(child => child.key);

        const children = [];
        const keyMap = {};

        // 遍历旧子节点数组，找出需要删除的节点
        for (let i = 0; i < oldChildren.length; i++) {
            const oldKey = oldChildren[i].key;
            const index = newKeys.indexOf(oldKey);

            // 如果旧子节点在新子节点数组中不存在，则需要删除该节点
            if (index === -1) {
                patches.push({
                    index: i,
                    patches: {
                        type: 'REMOVE',
                        node: oldChildren[i]
                    }
                });
            } else {
                // 如果旧子节点在新子节点数组中存在，则将该子节点加入 children 数组和 keyMap 中
                children[index] = oldChildren[i];
                keyMap[oldKey] = oldChildren[i];
            }
        }

        // 遍历新子节点数组，找出需要新增的节点
        for (let i = 0; i < newChildren.length; i++) {
            const newKey = newChildren[i].key;
            const index = oldKeys.indexOf(newKey);

            // 如果新子节点在旧子节点数组中不存在，则需要新增该节点
            if (index === -1) {
                patches.push({
                    index: i,
                    patches: {
                        type: 'ADD',
                        node: newChildren[i]
                    }
                });
            } else {
                // 如果新子节点在旧子节点数组中存在，则需要比较该子节点的差异
                const child = children[index];
                const childPatches = diff(newChildren[i], child);

                if (childPatches) {
        // 如果子节点需要修改，则将修改后的子节点加入 patches 数组

</script>